/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the tools applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qdbusviewer.h"
#include "qdbusmodel.h"
#include "servicesproxymodel.h"
//#include "propertydialog.h"
#include "logviewer.h"


#include <QtCore/QStringListModel>
#include <QtCore/QMetaProperty>
#include <QtCore/QSettings>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QAction>
#include <QtWidgets/QShortcut>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QSplitter>
#include <QtWidgets/QInputDialog>
#include <QtWidgets/QMessageBox>
#include <QtWidgets/QMenu>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QTreeWidget>
#include <QtWidgets/QHeaderView>
#include <QtDBus/QDBusConnectionInterface>
#include <QtDBus/QDBusInterface>
#include <QtDBus/QDBusMetaType>

#include <private/qdbusutil_p.h>
//#include "qdbusarg.hpp"


QDBusViewer::QDBusViewer(const QDBusConnection &connection, QWidget *parent)  :
    QWidget(parent),
    c(connection),
    objectPathRegExp(QLatin1String("\\[ObjectPath: (.*)\\]"))
{
    serviceFilterLine = new QLineEdit(this);
    serviceFilterLine->setPlaceholderText(tr("Search..."));

    // Create model for services list
    servicesModel = new QStringListModel(this);
    // Wrap service list model in proxy for easy filtering and interactive sorting
    servicesProxyModel = new ServicesProxyModel(this);
    servicesProxyModel->setSourceModel(servicesModel);
    servicesProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);

    servicesView = new QTableView(this);
    servicesView->setModel(servicesModel);
    // Make services grid view behave like a list view with headers
    servicesView->verticalHeader()->hide();
    servicesView->horizontalHeader()->setStretchLastSection(true);
    servicesView->setShowGrid(false);
    // Sort service list by default
    servicesView->setSortingEnabled(true);
    servicesView->sortByColumn(0, Qt::AscendingOrder);

    connect(serviceFilterLine, SIGNAL(textChanged(QString)), servicesProxyModel, SLOT(setFilterFixedString(QString)));

    tree = new QTreeView;
    tree->setContextMenuPolicy(Qt::CustomContextMenu);

    connect(tree, SIGNAL(activated(QModelIndex)), this, SLOT(activate(QModelIndex)));

    refreshAction = new QAction(tr("&Refresh"), tree);
    refreshAction->setData(42); // increase the amount of 42 used as magic number by one
    refreshAction->setShortcut(QKeySequence::Refresh);
    connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshChildren()));

    QShortcut *refreshShortcut = new QShortcut(QKeySequence::Refresh, tree);
    connect(refreshShortcut, SIGNAL(activated()), this, SLOT(refreshChildren()));

    QVBoxLayout *layout = new QVBoxLayout(this);
    topSplitter = new QSplitter(Qt::Vertical, this);
    layout->addWidget(topSplitter);

    log = new LogViewer;
    connect(log, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl)));

    splitter = new QSplitter(topSplitter);
    splitter->addWidget(servicesView);

    QWidget *servicesWidget = new QWidget;
    QVBoxLayout *servicesLayout = new QVBoxLayout(servicesWidget);
    servicesLayout->addWidget(serviceFilterLine);
    servicesLayout->addWidget(servicesView);
    splitter->addWidget(servicesWidget);
    splitter->addWidget(tree);

    topSplitter->addWidget(splitter);
    topSplitter->addWidget(log);

    connect(servicesView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
            this, SLOT(serviceChanged(QModelIndex)));
    connect(tree, SIGNAL(customContextMenuRequested(QPoint)),
            this, SLOT(showContextMenu(QPoint)));

    QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);

    if (c.isConnected()) {
        logMessage(QLatin1String("Connected to D-Bus."));
        QDBusConnectionInterface *iface = c.interface();
        connect(iface, SIGNAL(serviceRegistered(QString)),
                this, SLOT(serviceRegistered(QString)));
        connect(iface, SIGNAL(serviceUnregistered(QString)),
                this, SLOT(serviceUnregistered(QString)));
        connect(iface, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
                this, SLOT(serviceOwnerChanged(QString,QString,QString)));
    } else {
        logError(QLatin1String("Cannot connect to D-Bus: ") + c.lastError().message());
    }

    objectPathRegExp.setMinimal(true);

}

QDBusViewer::~QDBusViewer()
{
    QString c_name = c.name ();
    c.disconnectFromBus (c_name);
    c=QDBusConnection("None");
}

static inline QString topSplitterStateKey() { return QStringLiteral("topSplitterState"); }
static inline QString splitterStateKey() { return QStringLiteral("splitterState"); }

void QDBusViewer::saveState(QSettings *settings) const
{
    settings->setValue(topSplitterStateKey(), topSplitter->saveState());
    settings->setValue(splitterStateKey(), splitter->saveState());
}

void QDBusViewer::restoreState(const QSettings *settings)
{
    topSplitter->restoreState(settings->value(topSplitterStateKey()).toByteArray());
    splitter->restoreState(settings->value(splitterStateKey()).toByteArray());
}

void QDBusViewer::logMessage(const QString &msg)
{
    log->append(msg + QLatin1Char('\n'));
}

void QDBusViewer::logError(const QString &msg)
{
    log->append(QLatin1String("<font color=\"red\">Error: </font>") + msg.toHtmlEscaped() + QLatin1String("<br>"));
}

void QDBusViewer::refresh()
{
    servicesModel->removeRows(0, servicesModel->rowCount());

    if (c.isConnected()) {
        const QStringList serviceNames = c.interface()->registeredServiceNames();
        servicesModel->setStringList(serviceNames);
    }
}
#include <qdebug.h>
#include <QtDBus>
void register_Dbus_types()
{
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,qint8>>("QMap<qint8,qint8>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,qint16>>("QMap<qint8,qint16>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,qint32>>("QMap<qint8,qint32>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,qint64>>("QMap<qint8,qint64>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,quint8>>("QMap<qint8,quint8>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,quint16>>("QMap<qint8,quint16>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,quint32>>("QMap<qint8,quint32>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<qint8,quint64>>("QMap<qint8,quint64>");
//    qDebug()<<"QMap<qint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,QString>>("QMap<quint8,QString>");
//    qDebug()<<"QMap<quint8,QString>:"<<myCustomTypeId;

//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint8>>("QMap<quint8,qint8>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint16>>("QMap<quint8,qint16>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint32>>("QMap<quint8,qint32>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint64>>("QMap<quint8,qint64>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint8>>("QMap<quint8,quint8>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint16>>("QMap<quint8,quint16>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint32>>("QMap<quint8,quint32>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint64>>("QMap<quint8,quint64>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,QString>>("QMap<quint8,QString>");
//    qDebug()<<"QMap<quint8,QString>:"<<myCustomTypeId;

//    int myCustomTypeId = qRegisterMetaType<QMap<QString,qint8>>("QMap<quint8,qint8>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint16>>("QMap<quint8,qint16>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint32>>("QMap<quint8,qint32>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,qint64>>("QMap<quint8,qint64>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint8>>("QMap<quint8,quint8>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint16>>("QMap<quint8,quint16>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint32>>("QMap<quint8,quint32>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,quint64>>("QMap<quint8,quint64>");
//    qDebug()<<"QMap<quint8,int>:"<<myCustomTypeId;
//    int myCustomTypeId = qRegisterMetaType<QMap<quint8,QString>>("QMap<quint8,QString>");
//    qDebug()<<"QMap<quint8,QString>:"<<myCustomTypeId;


//    qDBusRegisterMetaType<QList<double>>();
//    qDBusRegisterMetaType<QList<qint64>>();
//    qDBusRegisterMetaType<QList<qint32>>();
//    qDBusRegisterMetaType<QList<qint16>>();
//    qDBusRegisterMetaType<QList<quint64>>();
//    qDBusRegisterMetaType<QList<quint32>>();
//    qDBusRegisterMetaType<QList<quint16>>();
//    qDBusRegisterMetaType<QMap<int,int>>();
//    qDBusRegisterMetaType<QMap<QString,int>>();
//    qDBusRegisterMetaType<QVariantMap>();
//    qDBusRegisterMetaType<QVariantList>();
}
void QDBusViewer::activate(const QModelIndex &item)
{
    if (!item.isValid())
        return;

    const QDBusModel *model = static_cast<const QDBusModel *>(item.model());

    BusSignature sig;
    sig.mService = currentService;
    sig.mPath = model->dBusPath(item);
    sig.mInterface = model->dBusInterface(item);
    sig.mName = model->dBusMethodName(item);
    sig.mTypeSig = model->dBusTypeSignature(item);
    sig.argNames = model->dBusMethodArgNames (item);
    sig.argTypes = model->dBusMethodArgTypes (item);

    switch (model->itemType(item)) {
    case QDBusModel::SignalItem:
        connectionRequested(sig);
        break;
    case QDBusModel::MethodItem:
        callMethod(sig);
        break;
    case QDBusModel::PropertyItem:
        getProperty(sig);
        break;
    default:
        break;
    }
}

void QDBusViewer::getProperty(const BusSignature &sig)
{
    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Get"));
    QList<QVariant> arguments;
    arguments << sig.mInterface << sig.mName;
    message.setArguments(arguments);
    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
}

void QDBusViewer::setProperty(const BusSignature &sig)
{
    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
    QMetaProperty prop = iface.metaObject()->property(iface.metaObject()->indexOfProperty(sig.mName.toLatin1()));

    bool ok;
    QString input = QInputDialog::getText(this, tr("Arguments"),
                    tr("Please enter the value of the property %1 (type %2)").arg(
                        sig.mName, QString::fromLatin1(prop.typeName())),
                    QLineEdit::Normal, QString(), &ok);
    if (!ok)
        return;

    QVariant value = input;
    if (!value.convert(prop.type())) {
        QMessageBox::warning(this, tr("Unable to marshall"),
                tr("Value conversion failed, unable to set property"));
        return;
    }

    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Set"));
    QList<QVariant> arguments;
    arguments << sig.mInterface << sig.mName << QVariant::fromValue(QDBusVariant(value));
    message.setArguments(arguments);
    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));

}

static QString getDbusSignature(const QMetaMethod& method)
{
    // create a D-Bus type signature from QMetaMethod's parameters
    QString sig;
    for (int i = 0; i < method.parameterCount(); ++i) {
        int type = method.parameterType(i);
        sig.append(QString::fromLatin1(QDBusMetaType::typeToSignature(type)));
    }
    return sig;
}


void QDBusViewer::callMethod(const BusSignature &sig)
{
    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
    const QMetaObject *mo = iface.metaObject();

    // find the method
    //    QMetaMethod method;
    //    for (int i = 0; i < mo->methodCount(); ++i) {
    //        const QString signature = QString::fromLatin1(mo->method(i).methodSignature());
    //        if (signature.startsWith(sig.mName) && signature.at(sig.mName.length()) == QLatin1Char('('))
    //            if (getDbusSignature(mo->method(i)) == sig.mTypeSig)//remove
    //              method = mo->method(i);
    //    }
    //    if (!method.isValid()) {
    //        QMessageBox::warning(this, tr("Unable to find method"),
    //                tr("Unable to find method %1 on path %2 in interface %3").arg(
    //                    sig.mName).arg(sig.mPath).arg(sig.mInterface));
    //        return;
    //    }
//    try
//    {
//        for (int i = 0; i < sig.argNames.count(); ++i) {
//            QString arg_type = sig.argTypes.at (i);
//            const char* types = arg_type.toLatin1 ().constData ();

//            DBusArgs::checkSuportType (types);


//        }

//    }catch(ArgException &e)
//    {
//        QString err(e.msg ());
//        QMessageBox::warning(this, tr("Unable to find method"),
//                             tr("Unable to find method %1 on path %2 in interface %3, paramters %4").arg(
//                                 sig.mName).arg(sig.mPath).arg(sig.mInterface).arg(err));
//        return;
//    }


//    PropertyDialog dialog;
//    QList<QVariant> args;

//    //    const QList<QByteArray> paramTypes = method.parameterTypes();
//    //    const QList<QByteArray> paramNames = method.parameterNames();
//    //    QList<int> types; // remember the low-level D-Bus type

//    for (int i = 0; i < sig.argNames.count(); ++i) {
//        dialog.addProperty(sig.argNames.at (i), sig.argTypes.at (i));
//    }

//    if (!sig.argNames.isEmpty()) {
//        dialog.setInfo(tr("Please enter parameters for the method \"%1\"").arg(sig.mName));

//        if (dialog.exec() != QDialog::Accepted)
//            return;

//        args = dialog.values();
//    }

//    try
//    {
//        QDBusArgument dbus_arg;
//        for (int i = 0; i < sig.argNames.count(); ++i) {
//            const char* arg_type = sig.argTypes.at(i).toLatin1 ().constData ();
//            const QString value = args[i].toString ();
//            DBusArgs args(arg_type,value);
//            args.BuildArguments (dbus_arg);

//        }
//        QList<QVariant> argumentList;
//        argumentList<<QVariant::fromValue(dbus_arg);
//        iface.callWithCallback (sig.mName,argumentList,this, SLOT(dumpMessage(QDBusMessage)));
//        if(iface.lastError().type()!=QDBusError::NoError)
//        {
//            throw ArgException( iface.lastError ().message ());
//        }

//    }catch(ArgException &e)
//    {
//        QString err(e.msg ());
//        QMessageBox::warning(this, tr("paramter error"),
//                             tr("Unable to find method %1 on path %2 in interface %3, paramters %4").arg(
//                                 sig.mName).arg(sig.mPath).arg(sig.mInterface).arg(err));
//    }


    // Try to convert the values we got as closely as possible to the
    // dbus signature. This is especially important for those input as strings
//    for (int i = 0; i < args.count(); ++i) {
//        QVariant a = args.at(i);
//        int desttype = types.at(i);
//        if (desttype < int(QMetaType::User) && desttype != int(QVariant::Map)
//            && a.canConvert(desttype)) {
//            args[i].convert(desttype);
//        }
//        // Special case - convert a value to a QDBusVariant if the
//        // interface wants a variant
//        if (types.at(i) == qMetaTypeId<QDBusVariant>())
//            args[i] = QVariant::fromValue(QDBusVariant(args.at(i)));
//    }

//    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, sig.mInterface,
//            sig.mName);
//    message.setArguments(args);
//    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
}

void QDBusViewer::showContextMenu(const QPoint &point)
{
    QModelIndex item = tree->indexAt(point);
    if (!item.isValid())
        return;

    const QDBusModel *model = static_cast<const QDBusModel *>(item.model());

    BusSignature sig;
    sig.mService = currentService;
    sig.mPath = model->dBusPath(item);
    sig.mInterface = model->dBusInterface(item);
    sig.mName = model->dBusMethodName(item);
    sig.mTypeSig = model->dBusTypeSignature(item);

    QMenu menu;
    menu.addAction(refreshAction);

    switch (model->itemType(item)) {
    case QDBusModel::SignalItem: {
        QAction *action = new QAction(tr("&Connect"), &menu);
        action->setData(1);
        menu.addAction(action);
        break; }
    case QDBusModel::MethodItem: {
        QAction *action = new QAction(tr("&Call"), &menu);
        action->setData(2);
        menu.addAction(action);
        break; }
    case QDBusModel::PropertyItem: {
        QAction *actionSet = new QAction(tr("&Set value"), &menu);
        actionSet->setData(3);
        QAction *actionGet = new QAction(tr("&Get value"), &menu);
        actionGet->setData(4);
        menu.addAction(actionSet);
        menu.addAction(actionGet);
        break; }
    default:
        break;
    }

    QAction *selectedAction = menu.exec(tree->viewport()->mapToGlobal(point));
    if (!selectedAction)
        return;

    switch (selectedAction->data().toInt()) {
    case 1:
        connectionRequested(sig);
        break;
    case 2:
        callMethod(sig);
        break;
    case 3:
        setProperty(sig);
        break;
    case 4:
        getProperty(sig);
        break;
    }
}

void QDBusViewer::connectionRequested(const BusSignature &sig)
{
    if (!c.connect(sig.mService, QString(), sig.mInterface, sig.mName, this,
              SLOT(dumpMessage(QDBusMessage)))) {
        logError(tr("Unable to connect to service %1, path %2, interface %3, signal %4").arg(
                    sig.mService).arg(sig.mPath).arg(sig.mInterface).arg(sig.mName));
    }
}

void QDBusViewer::dumpMessage(const QDBusMessage &message)
{
    QList<QVariant> args = message.arguments();
    QString out = QLatin1String("Received ");

    switch (message.type()) {
    case QDBusMessage::SignalMessage:
        out += QLatin1String("signal ");
        break;
    case QDBusMessage::ErrorMessage:
        out += QLatin1String("error message ");
        break;
    case QDBusMessage::ReplyMessage:
        out += QLatin1String("reply ");
        break;
    default:
        out += QLatin1String("message ");
        break;
    }

    out += QLatin1String("from ");
    out += message.service();
    if (!message.path().isEmpty())
        out += QLatin1String(", path ") + message.path();
    if (!message.interface().isEmpty())
        out += QLatin1String(", interface <i>") + message.interface() + QLatin1String("</i>");
    if (!message.member().isEmpty())
        out += QLatin1String(", member ") + message.member();
    out += QLatin1String("<br>");
    if (args.isEmpty()) {
        out += QLatin1String("&nbsp;&nbsp;(no arguments)");
    } else {
        out += QLatin1String("&nbsp;&nbsp;Arguments: ");
        for (const QVariant &arg : qAsConst(args)) {
            QString str = QDBusUtil::argumentToString(arg).toHtmlEscaped();
            // turn object paths into clickable links
            str.replace(objectPathRegExp, QLatin1String("[ObjectPath: <a href=\"qdbus://bus\\1\">\\1</a>]"));
            // convert new lines from command to proper HTML line breaks
            str.replace(QStringLiteral("\n"), QStringLiteral("<br/>"));
            out += str;
            out += QLatin1String(", ");
        }
        out.chop(2);
    }

    log->append(out);
}

void QDBusViewer::serviceChanged(const QModelIndex &index)
{
    delete tree->model();

    currentService.clear();
    if (!index.isValid())
        return;
    currentService = index.data().toString();

    tree->setModel(new QDBusViewModel(currentService, c));
    connect(tree->model(), SIGNAL(busError(QString)), this, SLOT(logError(QString)));
}

void QDBusViewer::serviceRegistered(const QString &service)
{
    if (service == c.baseService())
        return;

    servicesModel->insertRows(0, 1);
    servicesModel->setData(servicesModel->index(0, 0), service);
}

static QModelIndex findItem(QStringListModel *servicesModel, const QString &name)
{
    QModelIndexList hits = servicesModel->match(servicesModel->index(0, 0), Qt::DisplayRole, name);
    if (hits.isEmpty())
        return QModelIndex();

    return hits.first();
}

void QDBusViewer::serviceUnregistered(const QString &name)
{
    QModelIndex hit = findItem(servicesModel, name);
    if (!hit.isValid())
        return;
    servicesModel->removeRows(hit.row(), 1);
}

void QDBusViewer::serviceOwnerChanged(const QString &name, const QString &oldOwner,
                                      const QString &newOwner)
{
    QModelIndex hit = findItem(servicesModel, name);

    if (!hit.isValid() && oldOwner.isEmpty() && !newOwner.isEmpty())
        serviceRegistered(name);
    else if (hit.isValid() && !oldOwner.isEmpty() && newOwner.isEmpty())
        servicesModel->removeRows(hit.row(), 1);
    else if (hit.isValid() && !oldOwner.isEmpty() && !newOwner.isEmpty()) {
        servicesModel->removeRows(hit.row(), 1);
        serviceRegistered(name);
    }
}

void QDBusViewer::refreshChildren()
{
    QDBusModel *model = qobject_cast<QDBusModel *>(tree->model());
    if (!model)
        return;
    model->refresh(tree->currentIndex());
    tree->expandAll ();
}

void QDBusViewer::anchorClicked(const QUrl &url)
{
    if (url.scheme() != QLatin1String("qdbus"))
        // not ours
        return;

    // swallow the click without setting a new document
    log->setSource(QUrl());

    QDBusModel *model = qobject_cast<QDBusModel *>(tree->model());
    if (!model)
        return;

    QModelIndex idx = model->findObject(QDBusObjectPath(url.path()));
    if (!idx.isValid())
        return;

    tree->scrollTo(idx);
    tree->setCurrentIndex(idx);
}
